#include "pix5core.h"

#define PIX5APP TestApp





class Test
{

public:

	int _tests;
	int _success;
	int _fails;

	Test()
	{
		_tests=0;
		_success=0;
		_fails=0;
	}

	void printResult(int success)
	{
		if(success)
		{
			printf("\033[32;1m[OK]\033[m\n");
			_success++;
		}
		else
		{
			printf("\033[31;1m[FAIL]\033[m\n");
			_fails++;
		}
	}
	
	void printResultImpossible()
	{
		printf("\033[37;1m[UNKNOWN] Cannot be tested\033[m\n");
	}

	void printGroupResult()
	{
		printf("\n");
		if(_success)printf("\033[32m[SUCCESS]: %i\033[m\n\n",_success);
		if(_fails)printf("\033[31m[ FAILS ]: %i\033[m\n\n",_fails);
	}

};











//#######################################################
//###################    CORE    ########################
//#######################################################

class TestCore_Buffer:public Test
{
	Buffer _buffer;

public:

	void test()
	{
		printf("\033[45m[BUFFER]\033[m\n");

		testResize();
		testClear();
	
		printGroupResult();
	}

	void testResize()
	{
		_tests++;
		printf("\033[36m#[Buffer.resize()]\033[m\n");

		printResultImpossible();

	}

	void testClear()
	{
		_tests++;
		printf("\033[36m#[Buffer.clear()]\033[m\n");

		printResultImpossible();
	}


};

class TestCore_String:public Test
{

public:

	void test()
	{
		printf("\033[45m[STRING]\033[m\n");

		testGetLen();
		testSub();
		testLeft();
		testRight();
		testUpper();
		testLower();
		testPos();
		testFormat();
		
		
		printGroupResult();
	}

	void testGetLen()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[String.getLen()]\033[m\n");

		String _string;
		_string="asd";
		if(_string.getLen()==3)
			success = 1;

		printResult(success);

	}

	void testSub()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[String.sub()]\033[m\n");

		String _string;
		_string="abcDEFghi";
		if(_string.sub(3,3)=="DEF")
			success = 1;


		printResult(success);
	}

	void testLeft()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[String.left()]\033[m\n");

		String _string;
		_string="abcDEFghi";
		if(_string.left(3)=="abc")
			success = 1;


		printResult(success);

	}

	void testRight()
	{
		int success = 0;

		String _string;
		_string="abcDEFghi";
		if(_string.right(3)=="ghi")
			success = 1;

		_tests++;
		printf("\033[36m#[String.right()]\033[m\n");


		printResult(success);

	}

	void testUpper()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[String.upper()]\033[m\n");

		String _string;
		_string="abcDEFghi";
		if(_string.upper()=="ABCDEFGHI")
			success = 1;

		printResult(success);

	}

	void testLower()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[String.lower()]\033[m\n");

		String _string;
		_string="abcDEFghi";
		if(_string.lower()=="abcdefghi")
			success = 1;


		printResult(success);

	}

	void testPos()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[String.pos()]\033[m\n");

		String _string;
		_string="abcDEFghi";
		if(_string.pos("E",0)==4 && _string.pos("g",_string.getLen()-1,true)==6)
			success = 1;


		printResult(success);

	}

	void testFormat()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[String.format()]\033[m\n");

		String _string;
		_string="abcDEFghi";
		if(_string.format("abc%sghi%i","DEF",3)=="abcDEFghi3")
			success = 1;


		printResult(success);

	}


};

class TestCore_Array:public Test
{

public:

	void test()
	{
		printf("\033[45m[ARRAY]\033[m\n");

		testInsert();
		testAdd();
		testRemove();
		testRemoveDelete();
		testClear();
		testClearDelete();
		testFind();
		testSet();
		testGetSize();
		testSplit();
		
		printGroupResult();
	}

	void testInsert()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Array.insert()]\033[m\n");

		Array<int> _array;
		_array.add(8);
		_array.add(8);
		_array.add(8);
		_array.insert(25,2);
		if(_array[2]==25 && _array.getSize()==4)
			success=1;
		_array.clear();

		printResult(success);

	}

	void testAdd()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Array.add()]\033[m\n");

		Array<int> _array;
		_array.add(8);
		if(_array[0]==8)
			success=1;
		_array.clear();


		printResult(success);
	}

	void testRemove()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Array.remove()]\033[m\n");

		Array<int> _array;
		_array.add(8);
		_array.add(8);
		_array.add(8);
		_array.remove(1);
		if(_array.getSize()==2)
			success=1;
		_array.clear();

		printResult(success);
	}

	void testRemoveDelete()
	{
		_tests++;
		printf("\033[36m#[Array.removeDelete()]\033[m\n");

		printResultImpossible();
	}

	void testClear()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Array.clear()]\033[m\n");

		Array<int> _array;
		_array.add(8);
		_array.add(9);
		_array.add(10);
		_array.add(1);
		_array.clear();
		if(_array.getSize()==0)
			success=1;
		_array.clear();

		printResult(success);
	}

	void testClearDelete()
	{
		_tests++;
		printf("\033[36m#[Array.clearDelete()]\033[m\n");

		printResultImpossible();
	}

	void testFind()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Array.find()]\033[m\n");

		Array<int> _array;
		_array.add(8);
		_array.add(9);
		_array.add(10);
		if(_array.find(9)==1)
			success=1;
		_array.clear();

		printResult(success);
	}

	void testSet()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Array.set()]\033[m\n");

		Array<int> _array;
		_array.add(8);
		_array.set(0,5);
		if(_array[0]==5)
			success=1;
		_array.clear();

		printResult(success);
	}

	void testGetSize()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Array.getSize()]\033[m\n");


		Array<int> _array;
		_array.add(8);
		if(_array.getSize()==1)
			success=1;
		_array.clear();

		printResult(success);
	}

	void testSplit()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Array.split()]\033[m\n");

		Array<int> _array;
		Array<int> _array2;
		_array.add(1);
		_array.add(2);
		_array.add(3);
		_array.add(4);
		_array.split(2,_array2);
		if(_array.getSize()==2 && _array2.getSize()==2)
			success=1;
		_array.clear();
		_array2.clear();


		printResult(success);
	}



};

class TestCore_Dict:public Test
{

public:

	void test()
	{
		printf("\033[45m[DICT]\033[m\n");

		testFindKey();
		testAdd();
		testRemove();
		testClear();
		
		printGroupResult();
	}

	void testFindKey()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Dict.findKey()]\033[m\n");

		Dict<String,int> _dict;
		int _book,_pos;
		_dict.add("One",1);
		_dict.add("Two",2);
		_dict.add("Three",3);
		if(_dict.findKey("Two",_book,_pos))
			if(_book==0 && _pos==2)
				success = 1;
		_dict.clear();

		printResult(success);

	}

	void testAdd()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Dict.add()]\033[m\n");

		Dict<String,int> _dict;
		_dict.add("One",1);
		_dict.add("Two",2);
		_dict.add("Three",3);
		if(_dict["Two"]==2)
			success = 1;
		_dict.clear();

		printResult(success);
	}

	void testRemove()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Dict.remove()]\033[m\n");

		Dict<String,int> _dict;
		int _book,_pos;
		_dict.add("One",1);
		_dict.add("Two",2);
		_dict.add("Three",3);
		_dict.remove("Two");
		if(!_dict.findKey("Two",_book,_pos))
			success = 1;
		_dict.clear();

		printResult(success);
	}

	void testClear()
	{
		int success = 0;

		_tests++;
		printf("\033[36m#[Dict.clear()]\033[m\n");

		Dict<String,int> _dict;
		int _book,_pos;
		_dict.add("One",1);
		_dict.add("Two",2);
		_dict.add("Three",3);
		_dict.clear();
		if(!_dict.findKey("One",_book,_pos))
			if(!_dict.findKey("Two",_book,_pos))
				if(!_dict.findKey("Three",_book,_pos))
					success = 1;

		printResult(success);
	}


};

class TestCore:public Test
{

public:

	TestCore_Buffer _buffer;
	TestCore_String _string;
	TestCore_Array _array;
	TestCore_Dict _dict;

	void test()
	{

		printf("\033[44m[#####################################]\033[m\n");
		printf("\033[44m[########## CORE UNIT TESTS ##########]\033[m\n");
		printf("\033[44m[#####################################]\033[m\n\n");

		_buffer.test();
		_string.test();
		_array.test();
		_dict.test();
		

	}
};

//#######################################################














class TestApp:public App
{
	void onInit()
	{
		TestCore _testCore;

		//TEST GROUPS
		_testCore.test();


	}
};

#include "pix5main.h"

